home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / check.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-10-28  |  21KB  |  751 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __version__ = '14.3'
  5. __title__ = 'Dependency/Version Check Utility'
  6. __mod__ = 'hp-check'
  7. __doc__ = "Check the existence and versions of HPLIP dependencies. (Run as 'python ./check.py' from the HPLIP tarball before installation.)"
  8. import sys
  9. import os
  10. import getopt
  11. import commands
  12. import re
  13. from base.g import *
  14. from base import utils, tui, models
  15. from installer import dcheck
  16. from installer.core_install import *
  17. device_avail = False
  18.  
  19. try:
  20.     from base import device, pml
  21. except ImportError:
  22.     log.debug('Device library is not avail.')
  23.  
  24. device_avail = True
  25. USAGE = [
  26.     (__doc__, '', 'name', True),
  27.     ('Usage: %s [OPTIONS]' % __mod__, '', 'summary', True),
  28.     utils.USAGE_OPTIONS,
  29.     ('Compile-time check:', '-c or --compile', 'option', False),
  30.     ('Run-time check:', '-r or --run', 'option', False),
  31.     ('Compile and run-time checks:', '-b or --both (default)', 'option', False),
  32.     utils.USAGE_LOGGING1,
  33.     utils.USAGE_LOGGING2,
  34.     utils.USAGE_LOGGING3,
  35.     utils.USAGE_LOGGING_PLAIN,
  36.     utils.USAGE_HELP,
  37.     utils.USAGE_NOTES,
  38.     ('1. For checking for the proper build environment for the HPLIP supplied tarball (.tar.gz or .run),', '', 'note', False),
  39.     ('use the --compile or --both switches.', '', 'note', False),
  40.     ('2. For checking for the proper runtime environment for a distro supplied package (.deb, .rpm, etc),', '', 'note', False),
  41.     ('use the --runtime switch.', '', 'note', False)]
  42.  
  43. def usage(typ = 'text'):
  44.     if typ == 'text':
  45.         utils.log_title(__title__, __version__)
  46.     
  47.     utils.format_text(USAGE, typ, __title__, __mod__, __version__)
  48.     sys.exit(0)
  49.  
  50. build_str = 'HPLIP will not build, install, and/or function properly without this dependency.'
  51. pat_deviceuri = re.compile('(.*):/(.*?)/(\\S*?)\\?(?:serial=(\\S*)|device=(\\S*)|ip=(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}[^&]*)|zc=(\\S+))(?:&port=(\\d))?', re.I)
  52. pat_cups_error_log = re.compile('^loglevel\\s?(debug|debug2|warn|info|error|none)', re.I)
  53.  
  54. def parseDeviceURI(device_uri):
  55.     m = pat_deviceuri.match(device_uri)
  56.     if m is None:
  57.         raise Error(ERROR_INVALID_DEVICE_URI)
  58.     m is None
  59.     if not m.group(1).lower():
  60.         pass
  61.     back_end = ''
  62.     is_hp = back_end in ('hp', 'hpfax', 'hpaio')
  63.     if not m.group(2).lower():
  64.         pass
  65.     bus = ''
  66.     if bus not in ('usb', 'net', 'bt', 'fw', 'par'):
  67.         raise Error(ERROR_INVALID_DEVICE_URI)
  68.     bus not in ('usb', 'net', 'bt', 'fw', 'par')
  69.     if not m.group(3):
  70.         pass
  71.     model = ''
  72.     if not m.group(4):
  73.         pass
  74.     serial = ''
  75.     if not m.group(5):
  76.         pass
  77.     dev_file = ''
  78.     if not m.group(6):
  79.         pass
  80.     host = ''
  81.     zc = ''
  82.     if not host:
  83.         if not m.group(7):
  84.             pass
  85.         zc = host = ''
  86.     
  87.     if not m.group(8):
  88.         pass
  89.     port = 1
  90.     if bus == 'net':
  91.         
  92.         try:
  93.             port = int(port)
  94.         except (ValueError, TypeError):
  95.             port = 1
  96.  
  97.         if port == 0:
  98.             port = 1
  99.         
  100.     
  101.     return (back_end, is_hp, bus, model, serial, dev_file, host, zc, port)
  102.  
  103. num_errors = 0
  104. fmt = True
  105. overall_commands_to_run = []
  106. time_flag = DEPENDENCY_RUN_AND_COMPILE_TIME
  107.  
  108. try:
  109.     log.set_module(__mod__)
  110.     
  111.     try:
  112.         (opts, args) = getopt.getopt(sys.argv[1:], 'hl:gtcrb', [
  113.             'help',
  114.             'help-rest',
  115.             'help-man',
  116.             'help-desc',
  117.             'logging=',
  118.             'run',
  119.             'runtime',
  120.             'compile',
  121.             'both'])
  122.     except getopt.GetoptError:
  123.         e = None
  124.         log.error(e.msg)
  125.         usage()
  126.         sys.exit(1)
  127.  
  128.     if os.getenv('HPLIP_DEBUG'):
  129.         log.set_level('debug')
  130.     
  131.     log_level = 'info'
  132.     for o, a in opts:
  133.         if o in ('-h', '--help'):
  134.             usage()
  135.             continue
  136.         if o == '--help-rest':
  137.             usage('rest')
  138.             continue
  139.         if o == '--help-man':
  140.             usage('man')
  141.             continue
  142.         if o == '--help-desc':
  143.             print __doc__,
  144.             sys.exit(0)
  145.             continue
  146.         if o in ('-l', '--logging'):
  147.             log_level = a.lower().strip()
  148.             continue
  149.         if o == '-g':
  150.             log_level = 'debug'
  151.             continue
  152.         if o == '-t':
  153.             fmt = False
  154.             continue
  155.         if o in ('-c', '--compile'):
  156.             time_flag = DEPENDENCY_COMPILE_TIME
  157.             continue
  158.         if o in ('-r', '--runtime', '--run'):
  159.             time_flag = DEPENDENCY_RUN_TIME
  160.             continue
  161.         if o in ('-b', '--both'):
  162.             time_flag = DEPENDENCY_RUN_AND_COMPILE_TIME
  163.             continue
  164.     
  165.     if not log.set_level(log_level):
  166.         usage()
  167.     
  168.     if not fmt:
  169.         log.no_formatting()
  170.     
  171.     utils.log_title(__title__, __version__)
  172.     log.info(log.bold('Note: hp-check can be run in three modes:'))
  173.     for l in tui.format_paragraph('1. Compile-time check mode (-c or --compile): Use this mode before compiling the HPLIP supplied tarball (.tar.gz or .run) to determine if the proper dependencies are installed to successfully compile HPLIP.'):
  174.         log.info(l)
  175.     
  176.     for l in tui.format_paragraph('2. Run-time check mode (-r or --run): Use this mode to determine if a distro supplied package (.deb, .rpm, etc) or an already built HPLIP supplied tarball has the proper dependencies installed to successfully run.'):
  177.         log.info(l)
  178.     
  179.     for l in tui.format_paragraph('3. Both compile- and run-time check mode (-b or --both) (Default): This mode will check both of the above cases (both compile- and run-time dependencies).'):
  180.         log.info(l)
  181.     
  182.     log.info()
  183.     log_file = os.path.normpath('./hp-check.log')
  184.     log.info(log.bold('Saving output in log file: %s' % log_file))
  185.     log.debug('Log file=%s' % log_file)
  186.     if os.path.exists(log_file):
  187.         os.remove(log_file)
  188.     
  189.     log.set_logfile(log_file)
  190.     log.set_where(log.LOG_TO_CONSOLE_AND_FILE)
  191.     log.info('\nInitializing. Please wait...')
  192.     core = CoreInstall(MODE_CHECK)
  193.     core.init()
  194.     core.set_plugin_version()
  195.     tui.header('SYSTEM INFO')
  196.     log.info(log.bold('Basic system information:'))
  197.     log.info(core.sys_uname_info)
  198.     log.info()
  199.     log.info(log.bold('Distribution:'))
  200.     log.info('%s %s' % (core.distro_name, core.distro_version))
  201.     log.info()
  202.     log.info(log.bold('Checking Python version...'))
  203.     ver = sys.version_info
  204.     log.debug('sys.version_info = %s' % repr(ver))
  205.     ver_maj = ver[0]
  206.     ver_min = ver[1]
  207.     ver_pat = ver[2]
  208.     if ver_maj == 2:
  209.         if ver_min >= 1:
  210.             log.info('OK, version %d.%d.%d installed' % ver[:3])
  211.         else:
  212.             log.error('Version %d.%d.%d installed. Please update to Python >= 2.1' % ver[:3])
  213.             sys.exit(1)
  214.     
  215.     ui_toolkit = sys_conf.get('ui_toolkit', 'qt4')
  216.     if ui_toolkit == 'qt3':
  217.         log.info()
  218.         log.info(log.bold('Checking PyQt 3.x version...'))
  219.         
  220.         try:
  221.             import qt
  222.         except ImportError:
  223.             num_errors += 1
  224.             log.error('NOT FOUND OR FAILED TO LOAD!')
  225.  
  226.         qtMajor = int(qt.qVersion().split('.')[0])
  227.         if qtMajor < MINIMUM_QT_MAJOR_VER:
  228.             log.error('Incorrect version of Qt installed. Ver. 3.0.0 or greater required.')
  229.         else:
  230.             
  231.             try:
  232.                 pyqtVersion = qt.PYQT_VERSION_STR
  233.             except AttributeError:
  234.                 pyqtVersion = qt.PYQT_VERSION
  235.  
  236.             while pyqtVersion.count('.') < 2:
  237.                 pyqtVersion += '.0'
  238.             (maj_ver, min_ver, pat_ver) = pyqtVersion.split('.')
  239.             if pyqtVersion.find('snapshot') >= 0:
  240.                 log.error('A non-stable snapshot version of PyQt is installed (%s).' % pyqtVersion)
  241.                 num_errors += 1
  242.             else:
  243.                 
  244.                 try:
  245.                     maj_ver = int(maj_ver)
  246.                     min_ver = int(min_ver)
  247.                     pat_ver = int(pat_ver)
  248.                 except ValueError:
  249.                     (maj_ver, min_ver, pat_ver) = (0, 0, 0)
  250.  
  251.                 if (maj_ver < MINIMUM_PYQT_MAJOR_VER or maj_ver == MINIMUM_PYQT_MAJOR_VER) and min_ver < MINIMUM_PYQT_MINOR_VER:
  252.                     num_errors += 1
  253.                     log.error('HPLIP may not function properly with the version of PyQt that is installed (%d.%d.%d).' % (maj_ver, min_ver, pat_ver))
  254.                     log.error('Ver. %d.%d or greater required.' % (MINIMUM_PYQT_MAJOR_VER, MINIMUM_PYQT_MINOR_VER))
  255.                 else:
  256.                     log.info('OK, version %d.%d installed.' % (maj_ver, min_ver))
  257.         del qt
  258.     else:
  259.         log.info()
  260.         log.info(log.bold('Checking PyQt 4.x version...'))
  261.         
  262.         try:
  263.             import PyQt4
  264.         except ImportError:
  265.             num_errors += 1
  266.             log.error('NOT FOUND OR FAILED TO LOAD!')
  267.  
  268.         from PyQt4 import QtCore
  269.         log.info('OK, version %s installed.' % QtCore.PYQT_VERSION_STR)
  270.     log.info()
  271.     log.info(log.bold('Checking for CUPS...'))
  272.     cups_ok = True
  273.     (status, output) = utils.run('lpstat -r')
  274.     if status == 0:
  275.         log.info('Status: %s' % output.strip())
  276.     else:
  277.         log.error('Status: (Not available. CUPS may not be installed or not running.)')
  278.         cups_ok = False
  279.         num_errors += 1
  280.     if cups_ok:
  281.         (status, output) = utils.run('cups-config --version')
  282.         if status == 0:
  283.             log.info('Version: %s' % output.strip())
  284.         else:
  285.             log.error('Version: (Not available. CUPS may not be installed or not running.)')
  286.             cups_ok = False
  287.             num_errors += 1
  288.     
  289.     if cups_ok:
  290.         cups_conf = '/etc/cups/cupsd.conf'
  291.         
  292.         try:
  293.             f = file(cups_conf, 'r')
  294.         except (IOError, OSError):
  295.             log.warn('%s file not found or not accessible.' % cups_conf)
  296.  
  297.         for l in f:
  298.             m = pat_cups_error_log.match(l)
  299.             if m is not None:
  300.                 level = m.group(1).lower()
  301.                 log.info('error_log is set to level: %s' % level)
  302.                 break
  303.                 continue
  304.         
  305.     
  306.     log.info()
  307.     log.info(log.bold('Checking for dbus/python-dbus...'))
  308.     if dcheck.check_ps([
  309.         'dbus-daemon']):
  310.         log.info('dbus daemon is running.')
  311.     else:
  312.         log.warn('dbus daemon is not running.')
  313.     
  314.     try:
  315.         import dbus
  316.         
  317.         try:
  318.             log.info('python-dbus version: %s' % dbus.__version__)
  319.         except AttributeError:
  320.             
  321.             try:
  322.                 '.'.join([] % []([ str(x) for x in dbus.version ]))
  323.             except AttributeError:
  324.                 log.warn('python-dbus imported OK, but unknown version.')
  325.             except:
  326.                 None<EXCEPTION MATCH>AttributeError
  327.             
  328.  
  329.             None<EXCEPTION MATCH>AttributeError
  330.  
  331.     except ImportError:
  332.         log.warn('python-dbus not installed.')
  333.  
  334.     log.info()
  335.     if time_flag == DEPENDENCY_RUN_AND_COMPILE_TIME:
  336.         tui.header('COMPILE AND RUNTIME DEPENDENCIES')
  337.         log.note('To check for compile-time only dependencies, re-run hp-check with the -c parameter (ie, hp-check -c).')
  338.         log.note('To check for run-time only dependencies, re-run hp-check with the -r parameter (ie, hp-check -r).')
  339.     elif time_flag == DEPENDENCY_COMPILE_TIME:
  340.         tui.header('COMPILE TIME DEPENDENCIES')
  341.     elif time_flag == DEPENDENCY_RUN_TIME:
  342.         tui.header('RUNTIME DEPENDENCIES')
  343.     
  344.     log.info()
  345.     dd = core.dependencies.keys()
  346.     dd.sort()
  347.     for d in dd:
  348.         if (d == 'pyqt' or ui_toolkit != 'qt3' or d == 'pyqt4') and ui_toolkit != 'qt4':
  349.             continue
  350.         
  351.         log.debug('***')
  352.         if time_flag == DEPENDENCY_RUN_AND_COMPILE_TIME or time_flag == core.dependencies[d][4]:
  353.             log.info(log.bold('Checking for dependency: %s...' % core.dependencies[d][2]))
  354.             if core.have_dependencies[d]:
  355.                 log.info('OK, found.')
  356.             else:
  357.                 num_errors += 1
  358.                 if core.dependencies[d][4] == DEPENDENCY_RUN_AND_COMPILE_TIME:
  359.                     s = ''
  360.                 elif core.dependencies[d][4] == DEPENDENCY_COMPILE_TIME:
  361.                     s = '/COMPILE TIME ONLY'
  362.                 elif core.dependencies[d][4] == DEPENDENCY_RUN_TIME:
  363.                     s = '/RUNTIME ONLY'
  364.                 
  365.                 if core.dependencies[d][0]:
  366.                     log.error('NOT FOUND! This is a REQUIRED%s dependency. Please make sure that this dependency is installed before installing or running HPLIP.' % s)
  367.                 else:
  368.                     log.warn('NOT FOUND! This is an OPTIONAL%s dependency. Some HPLIP functionality may not function properly.' % s)
  369.                 if core.distro_supported():
  370.                     (packages_to_install, commands) = core.get_dependency_data(d)
  371.                     commands_to_run = []
  372.                     if packages_to_install:
  373.                         package_mgr_cmd = core.get_distro_data('package_mgr_cmd')
  374.                         if package_mgr_cmd:
  375.                             packages_to_install = ' '.join(packages_to_install)
  376.                             commands_to_run.append(utils.cat(package_mgr_cmd))
  377.                         
  378.                     
  379.                     if commands:
  380.                         commands_to_run.extend(commands)
  381.                     
  382.                     overall_commands_to_run.extend(commands_to_run)
  383.                     if len(commands_to_run) == 1:
  384.                         log.info('To install this dependency, execute this command:')
  385.                         log.info(commands_to_run[0])
  386.                     elif len(commands_to_run) > 1:
  387.                         log.info('To install this dependency, execute these commands:')
  388.                         for c in commands_to_run:
  389.                             log.info(c)
  390.                         
  391.                     
  392.                 
  393.             log.info()
  394.             continue
  395.     
  396.     if time_flag in (DEPENDENCY_RUN_TIME, DEPENDENCY_RUN_AND_COMPILE_TIME):
  397.         tui.header('HPLIP INSTALLATION')
  398.         scanning_enabled = utils.to_bool(sys_conf.get('configure', 'scanner-build', '0'))
  399.         log.info()
  400.         log.info(log.bold('Currently installed HPLIP version...'))
  401.         v = sys_conf.get('hplip', 'version')
  402.         home = sys_conf.get('dirs', 'home')
  403.         if v:
  404.             log.info("HPLIP %s currently installed in '%s'." % (v, home))
  405.             log.info()
  406.             log.info(log.bold("Current contents of '/etc/hp/hplip.conf' file:"))
  407.             
  408.             try:
  409.                 output = file('/etc/hp/hplip.conf', 'r').read()
  410.             except (IOError, OSError):
  411.                 e = None
  412.                 log.error('Could not access file: %s' % e.strerror)
  413.  
  414.             log.info(output)
  415.             log.info()
  416.             log.info(log.bold("Current contents of '/var/lib/hp/hplip.state' file:"))
  417.             
  418.             try:
  419.                 output = file(os.path.expanduser('/var/lib/hp/hplip.state'), 'r').read()
  420.             except (IOError, OSError):
  421.                 e = None
  422.                 log.error('Could not access file: %s' % e.strerror)
  423.  
  424.             log.info(output)
  425.             log.info()
  426.             log.info(log.bold("Current contents of '~/.hplip/hplip.conf' file:"))
  427.             
  428.             try:
  429.                 output = file(os.path.expanduser('~/.hplip/hplip.conf'), 'r').read()
  430.             except (IOError, OSError):
  431.                 e = None
  432.                 log.error('Could not access file: %s' % e.strerror)
  433.  
  434.             log.info(output)
  435.         else:
  436.             log.info('Not found.')
  437.         if device_avail:
  438.             if prop.usb_build:
  439.                 tui.header('DISCOVERED USB DEVICES')
  440.                 devices = device.probeDevices([
  441.                     'usb'])
  442.                 if devices:
  443.                     f = tui.Formatter()
  444.                     f.header = ('Device URI', 'Model')
  445.                     for d, dd in devices.items():
  446.                         f.add((d, dd[0]))
  447.                     
  448.                     f.output()
  449.                 else:
  450.                     log.info('No devices found.')
  451.             
  452.         
  453.         tui.header('INSTALLED CUPS PRINTER QUEUES')
  454.         lpstat_pat = re.compile('(\\S*): (.*)', re.IGNORECASE)
  455.         (status, output) = utils.run('lpstat -v')
  456.         log.info()
  457.         cups_printers = []
  458.         for p in output.splitlines():
  459.             
  460.             try:
  461.                 match = lpstat_pat.search(p)
  462.                 printer_name = match.group(1)
  463.                 device_uri = match.group(2)
  464.                 cups_printers.append((printer_name, device_uri))
  465.             continue
  466.             except AttributeError:
  467.                 continue
  468.             
  469.  
  470.         
  471.         log.debug(cups_printers)
  472.         if cups_printers:
  473.             for p in cups_printers:
  474.                 (printer_name, device_uri) = p
  475.                 if device_uri.startswith('cups-pdf:/') or device_uri.startswith('ipp://'):
  476.                     continue
  477.                 
  478.                 
  479.                 try:
  480.                     (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = parseDeviceURI(device_uri)
  481.                 except Error:
  482.                     (back_end, is_hp, bus, model, serial, dev_file, host, zc, port) = ('', False, '', '', '', '', '', '', 1)
  483.  
  484.                 log.info(log.bold(printer_name))
  485.                 log.info(log.bold('-' * len(printer_name)))
  486.                 x = 'Unknown'
  487.                 if back_end == 'hpfax':
  488.                     x = 'Fax'
  489.                 elif back_end == 'hp':
  490.                     x = 'Printer'
  491.                 
  492.                 log.info('Type: %s' % x)
  493.                 log.info('Device URI: %s' % device_uri)
  494.                 ppd = os.path.join('/etc/cups/ppd', printer_name + '.ppd')
  495.                 if os.path.exists(ppd):
  496.                     log.info('PPD: %s' % ppd)
  497.                     nickname_pat = re.compile('\\*NickName:\\s*\\"(.*)"', re.MULTILINE)
  498.                     f = file(ppd, 'r').read(4096)
  499.                     
  500.                     try:
  501.                         desc = nickname_pat.search(f).group(1)
  502.                     except AttributeError:
  503.                         desc = ''
  504.  
  505.                     log.info('PPD Description: %s' % desc)
  506.                     (status, output) = utils.run('lpstat -p%s' % printer_name)
  507.                     log.info('Printer status: %s' % output.replace('\n', ''))
  508.                     if back_end == 'hpfax' and 'HP Fax' not in desc:
  509.                         num_errors += 1
  510.                         log.error("Incorrect PPD file for fax queue '%s'. Fax queues must use 'HP-Fax-hplip.ppd'." % printer_name)
  511.                     elif back_end == 'hp' and 'HP Fax' in desc:
  512.                         num_errors += 1
  513.                         log.error("Incorrect PPD file for a print queue '%s'. Print queues must not use 'HP-Fax-hplip.ppd'." % printer_name)
  514.                     elif back_end not in ('hp', 'hpfax'):
  515.                         log.warn('Printer is not HPLIP installed. Printers must use the hp: or hpfax: CUPS backend to function in HPLIP.')
  516.                         num_errors += 1
  517.                     
  518.                 
  519.                 if device_avail and is_hp:
  520.                     d = None
  521.                     
  522.                     try:
  523.                         d = device.Device(device_uri)
  524.                     except Error:
  525.                         log.error('Device initialization failed.')
  526.                         continue
  527.                     
  528.  
  529.                     plugin = d.mq.get('plugin', PLUGIN_NONE)
  530.                     if plugin in (PLUGIN_REQUIRED, PLUGIN_OPTIONAL):
  531.                         if core.check_for_plugin():
  532.                             if plugin == PLUGIN_REQUIRED:
  533.                                 log.info('Required plug-in status: Installed')
  534.                             else:
  535.                                 log.info('Optional plug-in status: Installed')
  536.                         else:
  537.                             num_errors += 1
  538.                             if plugin == PLUGIN_REQUIRED:
  539.                                 log.error('Required plug-in status: Not installed')
  540.                             else:
  541.                                 log.warn('Optional plug-in status: Not installed')
  542.                     
  543.                     if bus in ('par', 'usb'):
  544.                         
  545.                         try:
  546.                             d.open()
  547.                         except Error:
  548.                             e = None
  549.                             log.error(e.msg)
  550.                             deviceid = ''
  551.  
  552.                         deviceid = d.getDeviceID()
  553.                         log.debug(deviceid)
  554.                         if not deviceid:
  555.                             log.error('Communication status: Failed')
  556.                             num_errors += 1
  557.                         else:
  558.                             log.info('Communication status: Good')
  559.                     elif bus == 'net':
  560.                         
  561.                         try:
  562.                             (error_code, deviceid) = d.getPML(pml.OID_DEVICE_ID)
  563.                         except Error:
  564.                             pass
  565.  
  566.                         if not deviceid:
  567.                             log.error('Communication status: Failed')
  568.                             num_errors += 1
  569.                         else:
  570.                             log.info('Communication status: Good')
  571.                 
  572.                 log.info()
  573.             
  574.         else:
  575.             log.warn('No queues found.')
  576.         if scanning_enabled:
  577.             tui.header('SANE CONFIGURATION')
  578.             log.info(log.bold("'hpaio' in '/etc/sane.d/dll.conf'..."))
  579.             
  580.             try:
  581.                 f = file('/etc/sane.d/dll.conf', 'r')
  582.             except IOError:
  583.                 log.error("'/etc/sane.d/dll.conf' not found. Is SANE installed?")
  584.                 num_errors += 1
  585.  
  586.             found = False
  587.             for line in f:
  588.                 if 'hpaio' in line:
  589.                     found = True
  590.                     continue
  591.             
  592.             if not found:
  593.                 log.info(log.bold("'hpaio' in '/etc/sane.d/dll.d/hplip'..."))
  594.                 
  595.                 try:
  596.                     f = file('/etc/sane.d/dll.d/hplip', 'r')
  597.                 except IOError:
  598.                     log.error("'/etc/sane.d/dll.d/hplip' not found.")
  599.                     num_errors += 1
  600.  
  601.                 found = False
  602.                 for line in f:
  603.                     if 'hpaio' in line:
  604.                         found = True
  605.                         continue
  606.                 
  607.             
  608.             if found:
  609.                 log.info("OK, found. SANE backend 'hpaio' is properly set up.")
  610.             else:
  611.                 num_errors += 1
  612.                 log.error("Not found. SANE backend 'hpaio' NOT properly setup (needs to be added to /etc/sane.d/dll.conf).")
  613.             log.info()
  614.             log.info(log.bold("Checking output of 'scanimage -L'..."))
  615.             if utils.which('scanimage'):
  616.                 (status, output) = utils.run('scanimage -L')
  617.                 log.info(output)
  618.             else:
  619.                 log.error('scanimage not found.')
  620.         
  621.         tui.header('PYTHON EXTENSIONS')
  622.         log.info(log.bold("Checking 'cupsext' CUPS extension..."))
  623.         
  624.         try:
  625.             import cupsext
  626.         except ImportError:
  627.             num_errors += 1
  628.             log.error('NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of cupsext.')
  629.  
  630.         log.info('OK, found.')
  631.         log.info()
  632.         log.info(log.bold("Checking 'pcardext' Photocard extension..."))
  633.         
  634.         try:
  635.             import pcardext
  636.         except ImportError:
  637.             num_errors += 1
  638.             log.error('NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of pcardext.')
  639.  
  640.         log.info('OK, found.')
  641.         log.info()
  642.         log.info(log.bold("Checking 'hpmudext' I/O extension..."))
  643.         
  644.         try:
  645.             import hpmudext
  646.             hpmudext_avail = True
  647.         except ImportError:
  648.             hpmudext_avail = False
  649.             num_errors += 1
  650.             log.error('NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of hpmudext.')
  651.  
  652.         log.info('OK, found.')
  653.         if scanning_enabled:
  654.             log.info()
  655.             log.info(log.bold("Checking 'scanext' SANE scanning extension..."))
  656.             
  657.             try:
  658.                 import scanext
  659.             except ImportError:
  660.                 num_errors += 1
  661.                 log.error('NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of scanext.')
  662.  
  663.             log.info('OK, found.')
  664.             log.info()
  665.         
  666.         if hpmudext_avail:
  667.             lsusb = utils.which('lsusb')
  668.             if lsusb:
  669.                 log.info()
  670.                 lsusb = os.path.join(lsusb, 'lsusb')
  671.                 (status, output) = utils.run('%s -d03f0:' % lsusb)
  672.                 if output:
  673.                     tui.header('USB I/O SETUP')
  674.                     log.info(log.bold('Checking for permissions of USB attached printers...'))
  675.                     lsusb_pat = re.compile('^Bus\\s([0-9a-fA-F]{3,3})\\sDevice\\s([0-9a-fA-F]{3,3}):\\sID\\s([0-9a-fA-F]{4,4}):([0-9a-fA-F]{4,4})(.*)', re.IGNORECASE)
  676.                     log.debug(output)
  677.                     for o in output.splitlines():
  678.                         ok = True
  679.                         match = lsusb_pat.search(o)
  680.                         if match is not None:
  681.                             (bus, dev, vid, pid, mfg) = match.groups()
  682.                             log.info('\nHP Device 0x%x at %s:%s: ' % (int(pid, 16), bus, dev))
  683.                             (result_code, deviceuri) = hpmudext.make_usb_uri(bus, dev)
  684.                             if result_code == hpmudext.HPMUD_R_OK:
  685.                                 log.info('    Device URI: %s' % deviceuri)
  686.                                 d = None
  687.                                 
  688.                                 try:
  689.                                     d = device.Device(deviceuri)
  690.                                 except Error:
  691.                                     continue
  692.  
  693.                                 if not d.supported:
  694.                                     continue
  695.                                 
  696.                             else:
  697.                                 log.warn('    Device URI: (Makeuri FAILED)')
  698.                             devnode = os.path.join('/', 'dev', 'bus', 'usb', bus, dev)
  699.                             if not os.path.exists(devnode):
  700.                                 devnode = os.path.join('/', 'proc', 'bus', 'usb', bus, dev)
  701.                             
  702.                             if os.path.exists(devnode):
  703.                                 log.info('    Device node: %s' % devnode)
  704.                                 (st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime, st_mtime, st_ctime) = os.stat(devnode)
  705.                                 log.info('    Mode: 0%o' % (st_mode & 511))
  706.                                 getfacl = utils.which('getfacl')
  707.                                 if getfacl:
  708.                                     getfacl = os.path.join(getfacl, 'getfacl')
  709.                                     (status, output) = utils.run('%s %s' % (getfacl, devnode))
  710.                                     log.info(output)
  711.                                 
  712.                             
  713.                         os.path.exists(devnode)
  714.                     
  715.                 
  716.             
  717.         
  718.     
  719.     tui.header('USER GROUPS')
  720.     groups = utils.which('groups')
  721.     if groups:
  722.         groups = os.path.join(groups, 'groups')
  723.         (status, output) = utils.run(groups)
  724.         if status == 0:
  725.             log.info(output)
  726.         
  727.     
  728.     tui.header('SUMMARY')
  729.     if num_errors:
  730.         if num_errors == 1:
  731.             log.error('1 error or warning.')
  732.         else:
  733.             log.error('%d errors and/or warnings.' % num_errors)
  734.         if overall_commands_to_run:
  735.             log.info()
  736.             log.info(log.bold('Summary of needed commands to run to satisfy missing dependencies:'))
  737.             for c in overall_commands_to_run:
  738.                 log.info(c)
  739.             
  740.         
  741.         log.info()
  742.         log.info('Please refer to the installation instructions at:')
  743.         log.info('http://hplip.sourceforge.net/install/index.html\n')
  744.     else:
  745.         log.info(log.green('No errors or warnings.'))
  746. except KeyboardInterrupt:
  747.     log.error('User exit')
  748.  
  749. log.info()
  750. log.info('Done.')
  751.